home *** CD-ROM | disk | FTP | other *** search
/ Aminet 12 / Aminet 12 (1996)(GTI - Schatztruhe)[!][Jun 1996].iso / Aminet / gfx / misc / SafeClip.lha / SafeClip / SASC / safeclip.c < prev    next >
C/C++ Source or Header  |  1996-03-29  |  5KB  |  227 lines
  1. /****h* Autodoc/safeclip.c [1.0] *
  2. *  NAME
  3. *    safeclip.c
  4. *  FUNCTION
  5. *    Interface to system rendering routines, but with clipping.
  6. *  AUTHOR
  7. *    Peter Knight: All programming.
  8. *    <pak@star.sr.bham.ac.uk>
  9. *  CREATION DATE
  10. *    24-Mar-96
  11. *  COPYRIGHT
  12. *    No restriction (Public Domain).
  13. *    Use these routines as you wish in your programs (a 
  14. *    mention in the credits would be nice, but it's up to
  15. *    you).
  16. **********
  17. */
  18.  
  19. #include <exec/types.h>
  20. #include <exec/memory.h>
  21. #include <proto/exec.h>
  22. #include <proto/graphics.h>
  23.  
  24. #include "safeclip.h"
  25.  
  26. /* Global variables. */
  27. LONG CLP_xmin, CLP_ymin, CLP_xmax, CLP_ymax;
  28. LONG (*CLP_vert)[2] = NULL, (*CLP_wrk)[2] = NULL;
  29. LONG CLP_nvert = 0, CLP_nvertmax;
  30. LONG CLP_lastx, CLP_lasty;
  31.  
  32. /* ASM prototypes */
  33. LONG __asm clip2d (register __a0 LONG *, register __a1 LONG *, 
  34.            register __d0 LONG);
  35. LONG __asm lineclip (register __a0 LONG *);
  36.  
  37. /****i* safeclip.c/Clip2d
  38. * NAME
  39. *   Clip2d
  40. * SYNOPSIS
  41. *   res = Clip2d (n)
  42. *   LONG Clip2d (LONG)
  43. * FUNCTION
  44. *   C interface to ASM routine for clipping filled polygons.
  45. * INPUTS
  46. *   n - Number of vertices in polygon
  47. * RESULTS
  48. *   res - Number of vertices in clipped polygon
  49. * SEE ALSO
  50. */
  51. static __inline LONG
  52. Clip2d (LONG n)
  53. {
  54.   return clip2d (CLP_vert[0], CLP_wrk[0], n);
  55. }
  56. /*********/
  57.  
  58. /****i* safeclip.c/ClipLine
  59. * NAME
  60. *   ClipLine
  61. * SYNOPSIS
  62. *   res = ClipLine ()
  63. *   LONG ClipLine (VOID)
  64. * FUNCTION
  65. *   C interface to ASM routine for clipping line segments.
  66. * INPUTS
  67. * RESULTS
  68. *   res - TRUE if any part of line was drawn, otherwise FALSE.
  69. * SEE ALSO
  70. */
  71. static __inline LONG
  72. ClipLine (VOID)
  73. {
  74.   return lineclip (CLP_vert[0]);
  75. }
  76. /*********/
  77.  
  78. /****** safeclip.c/SafeAreaEnd
  79. * NAME
  80. *   SafeAreaEnd
  81. * SYNOPSIS
  82. *        SafeAreaEnd (rp)
  83. *   VOID SafeAreaEnd (struct RastPort *)
  84. * FUNCTION
  85. *   Process buffer AreaDraw() instructions
  86. * INPUTS
  87. *   rp - Pointer to RastPort on which to draw.
  88. * RESULTS
  89. * SEE ALSO
  90. *   SafeAreaDraw
  91. */
  92. VOID
  93. SafeAreaEnd (struct RastPort *rp)
  94. {
  95.   if (CLP_nvert)
  96.     {
  97.       WORD i;
  98.       SafeAreaDraw (CLP_vert[0][0], CLP_vert[0][1]);  /* ensure shape is closed */
  99.       CLP_nvert = Clip2d (CLP_nvert);
  100.       AreaMove (rp, CLP_vert[0][0], CLP_vert[0][1]);
  101.       for (i = 1; i < CLP_nvert; i++)
  102.     AreaDraw (rp, CLP_vert[i][0], CLP_vert[i][1]);
  103.       AreaEnd (rp);
  104.       CLP_nvert = 0;
  105.     }
  106. }
  107. /*********/
  108.  
  109. /****** safeclip.c/SafeRectFill
  110. * NAME
  111. *   SafeRectFill
  112. * SYNOPSIS
  113. *        SafeRectFill (rp, x1, y1, x2, y2)
  114. *   VOID SafeRectFill (struct RastPort *, LONG, LONG, LONG, LONG)
  115. * FUNCTION
  116. *   Draw a filled rectangle
  117. * INPUTS
  118. *   rp - Pointer to RastPort on which to draw.
  119. *   (x1,y1) - Coordinates of upper left corner
  120. *   (x2,y2) - Coordinates of lower right corner
  121. * RESULTS
  122. * SEE ALSO
  123. */
  124. VOID
  125. SafeRectFill (struct RastPort *rp, LONG x1, LONG y1, LONG x2, LONG y2)
  126. {
  127.   SafeAreaDraw (x1, y1);
  128.   SafeAreaDraw (x2, y1);
  129.   SafeAreaDraw (x2, y2);
  130.   SafeAreaDraw (x1, y2);
  131.   SafeAreaEnd (rp);
  132. }
  133. /*********/
  134.  
  135. /****** safeclip.c/SafeDraw
  136. * NAME
  137. *   SafeDraw
  138. * SYNOPSIS
  139. *        SafeDraw (rp, x, y)
  140. *   VOID SafeDraw (struct RastPort *, LONG, LONG)
  141. * FUNCTION
  142. *   Move from previous point to new point and draw line.
  143. * INPUTS
  144. *   rp - Pointer to RastPort on which to draw.
  145. *   (x,y) - Coordinates of point to draw to
  146. * RESULTS
  147. * SEE ALSO
  148. *   SafeMove
  149. */
  150. VOID
  151. SafeDraw (struct RastPort *rp, LONG x, LONG y)
  152. {
  153.   CLP_vert[0][0] = CLP_lastx;
  154.   CLP_vert[0][1] = CLP_lasty;
  155.   CLP_vert[1][0] = x;
  156.   CLP_vert[1][1] = y;
  157.   if (ClipLine ())
  158.     {
  159.       Move (rp, CLP_vert[0][0], CLP_vert[0][1]);
  160.       Draw (rp, CLP_vert[1][0], CLP_vert[1][1]);
  161.     }
  162.   CLP_lastx = x;
  163.   CLP_lasty = y;
  164. }
  165. /*********/
  166.  
  167. /****** safeclip.c/SafeInit
  168. * NAME
  169. *   SafeInit
  170. * SYNOPSIS
  171. *   res = SafeInit (nvertmax)
  172. *   ULONG SafeInit (ULONG)
  173. * FUNCTION
  174. *   Initialise clipping routines
  175. * INPUTS
  176. *   nvertmax - Maximum number of vertices per polygon that you will use
  177. * RESULTS
  178. *   res - FALSE if everything was OK, otherwise TRUE
  179. * SEE ALSO
  180. *   SafeClose
  181. */
  182. ULONG
  183. SafeInit (ULONG nvertmax)
  184. {
  185.   CLP_nvertmax = nvertmax;
  186.   if (!(CLP_vert = (LONG (*)[2]) AllocVec (8 * CLP_nvertmax, MEMF_PUBLIC)))
  187.     return 1;
  188.   if (!(CLP_wrk = (LONG (*)[2]) AllocVec (8 * CLP_nvertmax, MEMF_PUBLIC)))
  189.     {
  190.       FreeVec (CLP_vert);
  191.       CLP_vert = 0;
  192.       return 2;
  193.     }
  194.   return 0;
  195. }
  196. /*********/
  197.  
  198. /****** safeclip.c/SafeClose
  199. * NAME
  200. *   SafeClose
  201. * SYNOPSIS
  202. *        SafeClose ()
  203. *   VOID SafeClose (VOID)
  204. * FUNCTION
  205. *   Free memory allocated by SafeInit()
  206. * INPUTS
  207. * RESULTS
  208. * SEE ALSO
  209. *   SafeInit
  210. */
  211. VOID
  212. SafeClose (VOID)
  213. {
  214.   if (CLP_wrk)
  215.     {
  216.       FreeVec (CLP_wrk);
  217.       CLP_wrk = 0;
  218.     }
  219.   if (CLP_vert)
  220.     {
  221.       FreeVec (CLP_vert);
  222.       CLP_vert = 0;
  223.     }
  224. }
  225. /*********/
  226.  
  227.